package com.misyi.designpattern.factory.abstractfactory;

/**
 * 抽象工厂模式
 *
 * @author licong
 * @date 2021-09-11 上午11:33
 */
public class AbstractFactoryPatternDemo {


    public static void main(String[] args) {
        // 产品 A1 和 B1 的组合
        ProductA productA1 = Factory1.get().createProductA();
        ProductB productB1 = Factory1.get().createProductB();
        productA1.execute();
        productB1.execute();

        // 假设现在需要将 A1 和 B1 的组合修改为 A3 和 B3
        // > 此时只需要修改工厂的创建逻辑


        // 产品 A2 和 B2 的组合
        ProductA productA2 = Factory2.get().createProductA();
        ProductB productB2 = Factory2.get().createProductB();
        productA2.execute();
        productB2.execute();
    }

    public interface ProductA {
        void execute();
    }

    public interface ProductB {
        void execute();
    }


    public static class ProductA1 implements ProductA {

        @Override
        public void execute() {
            System.out.println("产品 A1 的功能逻辑");
        }
    }

    public static class ProductA2 implements ProductA {

        @Override
        public void execute() {
            System.out.println("产品 A2 的功能逻辑");
        }
    }

    public static class ProductA3 implements ProductA {

        @Override
        public void execute() {
            System.out.println("产品 A3 的功能逻辑");
        }
    }

    public static class ProductB1 implements ProductB {

        @Override
        public void execute() {
            System.out.println("产品 B1 的功能逻辑");
        }
    }

    public static class ProductB2 implements ProductB {

        @Override
        public void execute() {
            System.out.println("产品 B2 的功能逻辑");
        }
    }

    public static class ProductB3 implements ProductB {

        @Override
        public void execute() {
            System.out.println("产品 B3 的功能逻辑");
        }
    }

    public interface Factory {
        ProductA createProductA();
        ProductB createProductB();
    }

    public static class Factory1 implements Factory {

        private static final Factory1 INSTANCE = new Factory1();

        private Factory1() {

        }

        public static Factory1 get() {
            return INSTANCE;
        }

        @Override
        public ProductA createProductA() {
//            return new ProductA1();
            return new ProductA3();
        }

        @Override
        public ProductB createProductB() {
//            return new ProductB1();
            return new ProductB3();
        }
    }

    public static class Factory2 implements Factory {

        private static final Factory2 INSTANCE = new Factory2();

        private Factory2() {

        }

        public static Factory2 get() {
            return INSTANCE;
        }
        @Override
        public ProductA createProductA() {
            return new ProductA2();
        }

        @Override
        public ProductB createProductB() {
            return new ProductB2();
        }
    }
}
